#------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # Base class for all TransAM calculators. Each instance of this class must provide
        
      
        

          
          
          # a calculate(asset) method.
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          
        
      
        

          1
          
          class Calculator
        
      
        

          
          
          
        
      
        

          
          
            # Include the fiscal year mixin
        
      
        

          1
          
            include FiscalYear
        
      
        

          
          
          
        
      
        

          1
          
            INFINITY = 999999999.9
        
      
        

          
          
          
        
      
        

          
          
            # All class instances should override this method to return a calculated value for the asset
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
              nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class ConditionEstimationCalculator < Calculator
        
      
        

          
          
          
        
      
        

          
          
            # determine the slope between two points
        
      
        

          1
          
            def slope(x1, y1, x2, y2)
        
      
        

          25
          
              dx = x2 - x1
        
      
        

          25
          
              dy = y2 - y1
        
      
        

          
          
          
        
      
        

          25
          
              if dy.abs < 0.0001
        
      
        

          2
          
               0.0
        
      
        

          23
          
              elsif dx.abs < 0.0001
        
      
        

          5
          
                -1.0
        
      
        

          
          
              else
        
      
        

          18
          
                dy.to_f / dx.to_f
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # Base class for calculating asset costs
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class CostCalculator < Calculator
        
      
        

          
          
          
        
      
        

          1
          
            protected
        
      
        

          
          
          
        
      
        

          
          
            # Returns the replacement year for the asset. This is either the schedule_replacement_year if set
        
      
        

          
          
            # or the policy_replacement_year otherwise
        
      
        

          
          
            # replacement year is in FY
        
      
        

          1
          
            def replacement_year(asset)
        
      
        

          2
          
              asset.scheduled_replacement_year.blank? ? asset.policy_replacement_year : asset.scheduled_replacement_year
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # future cost calculation. calculates cost plus compounded interest over the number of years
        
      
        

          1
          
            def future_cost(initial_cost, number_of_years, interest_rate)
        
      
        

          7
          
              initial_cost * (1 + interest_rate) ** number_of_years
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class CustomWeightedConditionRollupCalculator < Calculator
        
      
        

          
          
            
        
      
        

          
          
            # Calculates the last year for service given the asset sub type and the date the asset was placed
        
      
        

          
          
            # into service
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          2
          
              Rails.logger.debug "CustomWeightedConditionRollupCalculator.calculate(asset)"
        
      
        

          
          
          
        
      
        

          2
          
              ratings = asset.dependents.where('weight IS NOT NULL').pluck(:weight, :reported_condition_rating)
        
      
        

          2
          
              return nil if ratings.size == 0
        
      
        

          
          
          
        
      
        

          1
          
              temp_sum = 0
        
      
        

          1
          
              ratings.each do |rc|
        
      
        

          3
          
                temp_sum += rc[0] * (rc[1] || 0) # if no reported condition, default to 0 / Unknown
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          4
          
              return (temp_sum/(ratings.sum{|rc| rc[0]})).round # for now round
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class MedianConditionRollupCalculator < Calculator
        
      
        

          
          
            
        
      
        

          
          
            # Calculates the last year for service given the asset sub type and the date the asset was placed
        
      
        

          
          
            # into service
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          2
          
              Rails.logger.debug "MedianConditionRollupCalculator.calculate(asset)"
        
      
        

          
          
          
        
      
        

          2
          
              ratings = asset.dependents.pluck(:reported_condition_rating)
        
      
        

          2
          
              return nil if ratings.size == 0
        
      
        

          
          
          
        
      
        

          1
          
              tmp = ratings.sort
        
      
        

          1
          
              mid = (tmp.size / 2).to_i
        
      
        

          1
          
              return tmp[mid]
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # PurchasePricePlusInterestCalculator
        
      
        

          
          
          #
        
      
        

          
          
          # Calculates asset costs base on the initial price of the asset plus compounded
        
      
        

          
          
          # interest from the in service year (in FY) to the replacement year (in FY)
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class PurchasePricePlusInterestCalculator < CostCalculator
        
      
        

          
          
          
        
      
        

          1
          
            def calculate(asset)
        
      
        

          1
          
              calculate_on_date(asset)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def calculate_on_date(asset, on_date=nil)
        
      
        

          
          
          
        
      
        

          2
          
              Rails.logger.debug "PurchasePricePlusInterestCalculator.calculate(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # Get the initial cost of the asset
        
      
        

          2
          
              initial_cost = asset.cost
        
      
        

          2
          
              Rails.logger.debug "initial_cost #{initial_cost}"
        
      
        

          
          
          
        
      
        

          2
          
              purchase_date = asset.purchase_date
        
      
        

          
          
          
        
      
        

          2
          
              if on_date.nil?
        
      
        

          1
          
                num_years_to_replacement = [current_planning_year_year - fiscal_year_year_on_date(purchase_date), 0].max
        
      
        

          
          
              else
        
      
        

          1
          
                num_years_to_replacement = [fiscal_year_year_on_date(on_date)- fiscal_year_year_on_date(purchase_date), 0].max
        
      
        

          
          
              end
        
      
        

          2
          
              Rails.logger.debug "num_years_to_replacement #{num_years_to_replacement}"
        
      
        

          
          
          
        
      
        

          
          
              # inflation rate as decimal
        
      
        

          2
          
              inflation_rate = asset.policy_analyzer.get_annual_inflation_rate / 100.0
        
      
        

          2
          
              cost_in_future = future_cost(initial_cost, num_years_to_replacement, inflation_rate)
        
      
        

          2
          
              (cost_in_future + 0.5).floor # even rounds up
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # RehabilitationYearCalculator
        
      
        

          
          
          #
        
      
        

          
          
          # Returns the year that an asset should be rehabilitated based on the asset
        
      
        

          
          
          # and the asset's policy
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class RehabilitationYearCalculator < Calculator
        
      
        

          
          
          
        
      
        

          
          
            # Main entry point
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          6
          
              Rails.logger.debug "RehabilitationYearCalculator.calculate(asset)"
        
      
        

          
          
              # The policy rehabilitation month identifies the month of the assets service
        
      
        

          
          
              # that a rehabiliation should be performed. If not set, no rehabiliation
        
      
        

          
          
              # will be scheduled otherwise find the fiscal year that is x months after the
        
      
        

          
          
              # fiscal year the asset was placed in service
        
      
        

          6
          
              months_into_service = asset.policy_analyzer.get_rehabilitation_service_month
        
      
        

          6
          
              if months_into_service.to_i > 0
        
      
        

          
          
                # return the in service fiscal year plus the policy rehab year
        
      
        

          1
          
                fiscal_year_year_on_date(asset.in_service_date) + (months_into_service / 12)
        
      
        

          
          
              else
        
      
        

          
          
                nil
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            protected
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ReplacementCostCalculator
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ReplacementCostCalculator < CostCalculator
        
      
        

          
          
          
        
      
        

          
          
            # Determines the calculated replacement cost for an asset.
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          
          
              # The default behavior is to return the replacement cost of the asset from the schedule
        
      
        

          11
          
              asset.policy_analyzer.get_replacement_cost
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # As we are using the schedule, there is no difference using the date so we
        
      
        

          
          
            # simply delegate to the calculate method
        
      
        

          1
          
            def calculate_on_date(asset,on_date=nil)
        
      
        

          10
          
              calculate(asset)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ReplacementCostPlusInterestCalculator
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ReplacementCostPlusInterestCalculator < ReplacementCostCalculator
        
      
        

          
          
          
        
      
        

          1
          
            def calculate(asset)
        
      
        

          1
          
              calculate_on_date(asset)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # average replacement cost for the asset plus accrued interest
        
      
        

          
          
            # from the policy year (in FY) until the FY of the given date (the planning year by default)
        
      
        

          1
          
            def calculate_on_date(asset,on_date=nil)
        
      
        

          
          
          
        
      
        

          2
          
              Rails.logger.debug "ReplacementCostPlusInterestCalculator.calculate(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # Get the replacement cost of the asset
        
      
        

          2
          
              replacement_cost = asset.policy_analyzer.get_replacement_cost
        
      
        

          2
          
              Rails.logger.debug "initial_cost #{replacement_cost}"
        
      
        

          
          
          
        
      
        

          2
          
              if on_date.nil?
        
      
        

          1
          
                replacement_year = current_planning_year_year
        
      
        

          
          
              else
        
      
        

          1
          
                replacement_year = fiscal_year_year_on_date(on_date)
        
      
        

          
          
              end
        
      
        

          2
          
              Rails.logger.debug "actual replacement_year #{replacement_year}"
        
      
        

          
          
          
        
      
        

          
          
              # Calculate the number of years to carry the inflation rate
        
      
        

          2
          
              num_years_to_replacement = [replacement_year - asset.policy_analyzer.get_cost_fy_year, 0].max
        
      
        

          2
          
              Rails.logger.debug "num_years_to_replacement #{num_years_to_replacement}"
        
      
        

          
          
          
        
      
        

          
          
              # interest rate as decimal
        
      
        

          2
          
              inflation_rate = asset.policy_analyzer.get_annual_inflation_rate / 100.0
        
      
        

          
          
          
        
      
        

          2
          
              future_cost(replacement_cost, num_years_to_replacement, inflation_rate)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ServiceLifeAgeAndCondition
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ServiceLifeAgeAndCondition < ServiceLifeCalculator
        
      
        

          
          
          
        
      
        

          
          
            # Calculates the last year for service based on the maximum of the average asset
        
      
        

          
          
            # service life or the condition
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          1
          
              Rails.logger.debug "ServiceLifeAgeAndCondition.calculate(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # get the expected last year of service based on age
        
      
        

          1
          
              last_year_by_age = by_age(asset)
        
      
        

          
          
          
        
      
        

          
          
              # get the predicted last year of service based on the asset condition
        
      
        

          1
          
              last_year_by_condition = by_condition(asset)
        
      
        

          
          
          
        
      
        

          
          
              # return the minimum of the two
        
      
        

          1
          
              [last_year_by_age, last_year_by_condition].max
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ServiceLifeAgeOnly
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ServiceLifeAgeOnly < ServiceLifeCalculator
        
      
        

          
          
            
        
      
        

          
          
            # Calculates the last year for service given the asset sub type and the date the asset was placed
        
      
        

          
          
            # into service
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          4
          
              Rails.logger.debug "ServiceLifeAgeOnly.calculate(asset)"
        
      
        

          
          
              
        
      
        

          4
          
              by_age(asset)
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ServiceLifeAgeOr`Condition
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ServiceLifeAgeOrCondition < ServiceLifeCalculator
        
      
        

          
          
          
        
      
        

          
          
            # Calculates the last year for service based on the minimum of the average asset
        
      
        

          
          
            # service life or the condition
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          1
          
              Rails.logger.debug "ServiceLifeAgeAndCondition.calculate(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # get the expected last year of service based on age
        
      
        

          1
          
              last_year_by_age = by_age(asset)
        
      
        

          
          
          
        
      
        

          
          
              # get the predicted last year of service based on the asset condition
        
      
        

          1
          
              last_year_by_condition = by_condition(asset)
        
      
        

          
          
          
        
      
        

          
          
              # return the minimum of the two
        
      
        

          1
          
              [last_year_by_age, last_year_by_condition].min
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ServiceLifeCalculator
        
      
        

          
          
          #
        
      
        

          
          
          # base class for ServiceLife calculators
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ServiceLifeCalculator < Calculator
        
      
        

          
          
          
        
      
        

          1
          
            protected
        
      
        

          
          
          
        
      
        

          
          
            # calculate the service life based on the in_service_date FY plus the minimum
        
      
        

          
          
            # espected life of the asset. If the asset has been rehabilitated we factor
        
      
        

          
          
            # in any increase in longevity based on the current policy
        
      
        

          1
          
            def by_age(asset)
        
      
        

          
          
          
        
      
        

          11
          
              year = fiscal_year_year_on_date(asset.in_service_date) + (asset.expected_useful_life / 12)
        
      
        

          11
          
              if asset.last_rehabilitation_date.present?
        
      
        

          
          
                asset.rehabilitation_updates.each do |evt|
        
      
        

          
          
                  year += (evt.extended_useful_life_months / 12)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          11
          
              year
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Calculate the service life based on the minimum of condition
        
      
        

          
          
            # returns in FY
        
      
        

          1
          
            def by_condition(asset)
        
      
        

          
          
              # Iterate over all the condition update events from earliest to latest
        
      
        

          
          
              # and find the first year (if any) that the  policy replacement became
        
      
        

          
          
              # effective
        
      
        

          6
          
              events = asset.condition_updates.reload
        
      
        

          6
          
              condition_threshold = asset.policy_analyzer.get_condition_threshold
        
      
        

          6
          
              Rails.logger.debug "Found #{events.count} events."
        
      
        

          6
          
              Rails.logger.debug "Condition threshold = #{condition_threshold}."
        
      
        

          6
          
              events.each do |event|
        
      
        

          6
          
                Rails.logger.debug "Event date = #{event.event_date}, Rating = #{event.assessed_rating}."
        
      
        

          6
          
                if event.assessed_rating <= condition_threshold
        
      
        

          3
          
                  Rails.logger.debug "returning #{fiscal_year_year_on_date(event.event_date)}"
        
      
        

          3
          
                  return fiscal_year_year_on_date(event.event_date)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              # if we didn't find a condition event that would make the policy effective
        
      
        

          
          
              # we can simply return the age constraint
        
      
        

          3
          
              Rails.logger.debug "returning value from policy age"
        
      
        

          
          
          
        
      
        

          3
          
              last_year_by_age = by_age(asset)
        
      
        

          
          
          
        
      
        

          3
          
              if last_year_by_age <= fiscal_year_year_on_date(Date.today) + 1
        
      
        

          2
          
                fiscal_year_year_on_date(Date.today) + 2
        
      
        

          
          
              else
        
      
        

          1
          
                last_year_by_age
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # ServiceLifeConditionOnly
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class ServiceLifeConditionOnly < ServiceLifeCalculator
        
      
        

          
          
            
        
      
        

          
          
            # Calculates the last year for service based on the condition of the asset
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          1
          
              Rails.logger.debug "ServiceLifeConditionOnly.calculate(asset)"
        
      
        

          
          
          
        
      
        

          1
          
              by_condition(asset)    
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #  This calculator is not used and is broken.
        
      
        

          
          
          # It estimates the slope for a straight line estimation based on the last condition update ONLY. It doesn't take into account all the updates and therefore can reflect a very inaccurate slope if the last update is vatly different from the rest.
        
      
        

          
          
          # We currently use the Google Chart API that has trendlines of scatter plots.
        
      
        

          
          
          
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          
          
          #
        
      
        

          
          
          # StraightLineEstimationCalculator
        
      
        

          
          
          #
        
      
        

          
          
          #------------------------------------------------------------------------------
        
      
        

          1
          
          class StraightLineEstimationCalculator < ConditionEstimationCalculator
        
      
        

          
          
          
        
      
        

          
          
            # Estimates the condition rating of an asset using straight-line depreciation
        
      
        

          
          
            # based on
        
      
        

          
          
            #
        
      
        

          
          
            # 1] a measured rate of change if the asset has one or more condition updates, or
        
      
        

          
          
            # 2] the expected rate of change if no updates have been posted against the asset
        
      
        

          
          
            #
        
      
        

          
          
            # If the asset has mileage reported then the measured rate of change will be the minimum
        
      
        

          
          
            # of the condition assement or milege assessment
        
      
        

          
          
            #
        
      
        

          1
          
            def calculate(asset)
        
      
        

          8
          
              calculate_on_date(asset)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def calculate_on_date(asset,on_date=nil)
        
      
        

          
          
          
        
      
        

          8
          
              Rails.logger.debug "StraightLineEstimationCalculator.calculate(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # get the maximum and minimum rating for a new asset
        
      
        

          8
          
              max_rating = ConditionType.max_rating  # Usually 5.0 for FTA applicaitons
        
      
        

          8
          
              min_rating = ConditionType.min_rating  # Usually 1.0 for FTA applications
        
      
        

          
          
          
        
      
        

          
          
              # this is the rating that indicates the asset is at the end of its useful life. Usually 2.5 for FTA applications
        
      
        

          8
          
              condition_threshold = asset.policy_analyzer.get_condition_threshold
        
      
        

          
          
          
        
      
        

          
          
              # determine the minimum estimated rating, this is the one with the most negative slope
        
      
        

          8
          
              slopes = calculate_slope(asset, min_rating, max_rating)
        
      
        

          
          
          
        
      
        

          
          
              # determine the scale factor to make the mileage in the same interval as condition
        
      
        

          8
          
              scale_factor = 1.0
        
      
        

          8
          
              max_service_life_miles = asset.policy_analyzer.get_max_service_life_miles
        
      
        

          8
          
              unless max_service_life_miles.nil?
        
      
        

          
          
                if max_service_life_miles > 0
        
      
        

          
          
                  scale_factor = (max_rating - condition_threshold) / max_service_life_miles
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          8
          
              min_slope = [slopes[:condition_slope], slopes[:mileage_slope] * scale_factor].min
        
      
        

          8
          
              if on_date.nil?
        
      
        

          8
          
                est_rating = max_rating + (min_slope * asset.age)
        
      
        

          
          
              else
        
      
        

          
          
                est_rating = max_rating + (min_slope * asset.age(on_date))
        
      
        

          
          
              end
        
      
        

          8
          
              Rails.logger.debug "est rating = #{est_rating}"
        
      
        

          
          
              # make sure we don't go below the minimum. This is possible as the slope can extend infinitely for extreme cases
        
      
        

          8
          
              [est_rating.round(2), min_rating].max
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Estimates the last servicable year for the asset based on the last reported condition. If no
        
      
        

          
          
            # condition has been reported, the policy year is returned
        
      
        

          
          
            # returned in FY
        
      
        

          1
          
            def last_servicable_year(asset)
        
      
        

          
          
          
        
      
        

          7
          
              Rails.logger.debug "StraightLineEstimationCalculator.last_servicable_year(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # get the maximum and minimum rating for a new asset
        
      
        

          7
          
              max_rating = ConditionType.max_rating  # Usually 5.0 for FTA applicaitons
        
      
        

          7
          
              min_rating = ConditionType.min_rating  # Usually 1.0 for FTA applications
        
      
        

          
          
          
        
      
        

          
          
              # this is the rating that indicates the asset is at the end of its useful life. Usually 2.5 for FTA applications
        
      
        

          7
          
              condition_threshold = asset.policy_analyzer.get_condition_threshold
        
      
        

          
          
          
        
      
        

          
          
              # get max service life in months
        
      
        

          7
          
              max_service_life_months = asset.policy_analyzer.get_max_service_life_miles
        
      
        

          
          
          
        
      
        

          7
          
              years_policy    = asset.expected_useful_life.nil? ? max_service_life_months / 12.0 : asset.expected_useful_life / 12.0
        
      
        

          7
          
              years_mileage   = INFINITY
        
      
        

          7
          
              years_condition = INFINITY
        
      
        

          
          
          
        
      
        

          
          
              # Using the slope intercept formula y = mx + b
        
      
        

          
          
              #    where m is the slope
        
      
        

          
          
              #    b in the y intercept (max_rating)
        
      
        

          
          
              # we can solve for x (year) when we know y (condition) by re-arranging to
        
      
        

          
          
              # x = (y - b) / m
        
      
        

          
          
          
        
      
        

          7
          
              slopes = calculate_slope(asset, min_rating, max_rating)
        
      
        

          
          
              # condition
        
      
        

          7
          
              m = slopes[:condition_slope]
        
      
        

          7
          
              if m.abs.between?(0.00001, 0.99999)
        
      
        

          5
          
                b = max_rating
        
      
        

          5
          
                y = condition_threshold
        
      
        

          5
          
                Rails.logger.debug "y = mx + b => #{y} = #{m}x + #{b}"
        
      
        

          5
          
                x = (y - b) / m
        
      
        

          5
          
                Rails.logger.debug "x = (y - b) / m  => #{x} = (#{y} - #{b}) + #{m}"
        
      
        

          
          
                # Take care of any rounding errors
        
      
        

          5
          
                years_condition = (x + 0.1).to_i
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # mileage
        
      
        

          7
          
              max_service_life_miles = asset.policy_analyzer.get_max_service_life_miles
        
      
        

          7
          
              unless max_service_life_miles.nil?
        
      
        

          
          
                m = slopes[:mileage_slope]
        
      
        

          
          
                if m.abs.between?(0.00001, 0.99999)
        
      
        

          
          
                  b = max_service_life_miles
        
      
        

          
          
                  y = 0
        
      
        

          
          
                  x = (y - b) / m
        
      
        

          
          
                  # Take care of any rounding errors
        
      
        

          
          
                  years_mileage = (x + 0.1).to_i
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # return the last year that the asset is viable
        
      
        

          7
          
              Rails.logger.debug "years_policy = #{years_policy}, years_mileage = #{years_mileage}, years_condition = #{years_condition}"
        
      
        

          7
          
              fiscal_year_year_on_date(asset.in_service_date) + [years_policy, years_mileage, years_condition].min
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            protected
        
      
        

          1
          
              def calculate_slope(asset, min_rating, max_rating)
        
      
        

          
          
                #
        
      
        

          
          
                # We calculate the slope (y2 - y1) / (x2 - x2) where the x axis is the years and the y axis is the rating
        
      
        

          
          
                #   point (x1, y1) is the new asset (0 years, max_condition)
        
      
        

          
          
                #   point (x2, y2) is the last known data point if we have one or the end of useful life determined by
        
      
        

          
          
                #                  the policy if we dont
        
      
        

          
          
          
        
      
        

          
          
                # slope should always be negative as an asset's rating lowers over time
        
      
        

          
          
          
        
      
        

          
          
                # this is the rating that indicates the asset is at the end of its useful life. Usually 2.5 for FTA applications
        
      
        

          15
          
                condition_threshold = asset.policy.condition_threshold
        
      
        

          
          
          
        
      
        

          
          
                # Get what we need from the policy
        
      
        

          15
          
                max_service_life_months = asset.policy_analyzer.get_max_service_life_months
        
      
        

          15
          
                max_service_life_miles = asset.policy_analyzer.get_max_service_life_miles
        
      
        

          
          
          
        
      
        

          
          
                # this is the max number of years for the asset, i.e. the number of years before the asset's rating is expected to
        
      
        

          
          
                # reach the condition_threshold value
        
      
        

          15
          
                years_policy = asset.expected_useful_life.nil? ? max_service_life_months / 12.0 : asset.expected_useful_life / 12.0
        
      
        

          
          
          
        
      
        

          15
          
                Rails.logger.debug "asset.age=#{asset.age}, threshold=#{condition_threshold}, min_rating=#{min_rating}, max_rating=#{max_rating}"
        
      
        

          
          
          
        
      
        

          
          
                # Assets always rated at the max value when they are new
        
      
        

          15
          
                x1 = 0
        
      
        

          15
          
                y1 = max_rating
        
      
        

          
          
          
        
      
        

          
          
                # we might calculate this later if we have data
        
      
        

          15
          
                mileage_slope = 0.0
        
      
        

          
          
          
        
      
        

          
          
                # If there are no condition updates then just return the policy based
        
      
        

          
          
                # estimation
        
      
        

          15
          
                if asset.condition_updates.empty?
        
      
        

          7
          
                  Rails.logger.debug "No condition updates."
        
      
        

          7
          
                  x2 = years_policy
        
      
        

          7
          
                  y2 = condition_threshold
        
      
        

          7
          
                  Rails.logger.debug "x1=#{x1} y1=#{y1} x2=#{x2} y2=#{y2}"
        
      
        

          7
          
                  condition_slope = slope(x1, y1, x2, y2)
        
      
        

          7
          
                  Rails.logger.debug "Slope = #{condition_slope}."
        
      
        

          
          
                else
        
      
        

          
          
                  # We determine the new slope from the last data point reported
        
      
        

          8
          
                  condition_report = asset.condition_updates.last
        
      
        

          
          
          
        
      
        

          
          
                  #Rails.logger.debug condition_report.inspect
        
      
        

          8
          
                  last_rating   = condition_report.assessed_rating
        
      
        

          8
          
                  age_at_report = asset.age(condition_report.event_date)
        
      
        

          
          
          
        
      
        

          
          
                  # Determine the current slope
        
      
        

          8
          
                  x2 = age_at_report
        
      
        

          8
          
                  y2 = last_rating
        
      
        

          8
          
                  Rails.logger.debug "x1=#{x1} y1=#{y1} x2=#{x2} y2=#{y2}"
        
      
        

          8
          
                  condition_slope = slope(x1, y1, x2, y2)
        
      
        

          8
          
                  Rails.logger.debug "Slope = #{condition_slope}."
        
      
        

          
          
          
        
      
        

          
          
                  # See if we can do a mileage calculation
        
      
        

          8
          
                  unless max_service_life_miles.nil?
        
      
        

          
          
                    if max_service_life_miles && age_at_report > 0
        
      
        

          
          
                      # Here the slope is based on the number of miles remaining. This keeps the
        
      
        

          
          
                      # slope in the same direction
        
      
        

          
          
                      y1 = max_service_life_miles
        
      
        

          
          
                      y2 = max_service_life_miles - (asset.reported_mileage.nil? ? 0 : asset.reported_mileage)
        
      
        

          
          
                      # get the slope
        
      
        

          
          
                      mileage_slope = slope(x1, y1, x2, y2)
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          15
          
                return {:condition_slope => condition_slope, :mileage_slope => mileage_slope}
        
      
        

          
          
          
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class WeightedAverageConditionRollupCalculator < Calculator
        
      
        

          
          
            
        
      
        

          
          
            # Calculates the last year for service given the asset sub type and the date the asset was placed
        
      
        

          
          
            # into service
        
      
        

          1
          
            def calculate(asset)
        
      
        

          
          
          
        
      
        

          2
          
              Rails.logger.debug "WeightedAverageConditionRollupCalculator.calculate(asset)"
        
      
        

          
          
          
        
      
        

          
          
              # only assets with a replacement cost really have a weight so can ignore any without
        
      
        

          2
          
              return nil if not (asset.respond_to? :reported_condition_rating)
        
      
        

          5
          
              ratings = asset.dependents.where('scheduled_replacement_cost > 0').map{|x| [x.scheduled_replacement_cost, x.reported_condition_rating]}
        
      
        

          2
          
              return nil if ratings.size == 0
        
      
        

          
          
          
        
      
        

          1
          
              temp_sum = 0
        
      
        

          1
          
              ratings.each do |rc|
        
      
        

          3
          
                temp_sum += rc[0] * (rc[1] || 0) # if no reported condition, default to 0 / Unknown
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          4
          
              return (temp_sum/(ratings.sum{|rc| rc[0]})).round # for now round
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          #-------------------------------------------------------------------------------
        
      
        

          
          
          # ActivitiesController
        
      
        

          
          
          #
        
      
        

          
          
          #
        
      
        

          
          
          #-------------------------------------------------------------------------------
        
      
        

          1
          
          class ActivitiesController < OrganizationAwareController
        
      
        

          
          
          
        
      
        

          1
          
            before_action :set_activity,          :only =>  [:show, :edit, :update, :destroy]
        
      
        

          1
          
            before_action :reformat_date_fields,  :only =>  [:create, :update]
        
      
        

          
          
          
        
      
        

          1
          
            INDEX_KEY_LIST_VAR  = "activities_list_cache_var"
        
      
        

          1
          
            ACTIVE_FLAG         = '1'
        
      
        

          1
          
            DASHBOARD_FLAG      = '2'
        
      
        

          1
          
            SYSTEM_FLAG         = '3'
        
      
        

          
          
          
        
      
        

          1
          
            ACTIVITY_FLAGS = [
        
      
        

          
          
              ["Active", ACTIVE_FLAG],
        
      
        

          
          
              ["Show in Dashboard", DASHBOARD_FLAG],
        
      
        

          
          
              ["System", SYSTEM_FLAG]
        
      
        

          
          
            ]
        
      
        

          
          
          
        
      
        

          1
          
            add_breadcrumb "Home", :root_path
        
      
        

          1
          
            add_breadcrumb "Activities", :activities_path
        
      
        

          
          
          
        
      
        

          
          
            # Lock down the controller
        
      
        

          1
          
            authorize_resource
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # GET /activities
        
      
        

          
          
            # GET /activities.json
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def index
        
      
        

          
          
          
        
      
        

          
          
              # Start to set up the query
        
      
        

          
          
              conditions  = []
        
      
        

          
          
              values      = []
        
      
        

          
          
          
        
      
        

          
          
              @activity_flag_filter = params[:activity_flag_filter]
        
      
        

          
          
              if @activity_flag_filter.blank?
        
      
        

          
          
                @activity_flag_filter = []
        
      
        

          
          
              else
        
      
        

          
          
                if @activity_flag_filter.include? ACTIVE_FLAG
        
      
        

          
          
                  conditions << 'active = ?'
        
      
        

          
          
                  values << true
        
      
        

          
          
                end
        
      
        

          
          
                if @activity_flag_filter.include? DASHBOARD_FLAG
        
      
        

          
          
                  conditions << 'show_in_dashboard = ?'
        
      
        

          
          
                  values << true
        
      
        

          
          
                end
        
      
        

          
          
                if @activity_flag_filter.include? SYSTEM_FLAG
        
      
        

          
          
                  conditions << 'system_activity = ?'
        
      
        

          
          
                  values << true
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Get the activities
        
      
        

          
          
              @activities = Activity.where(conditions.join(' AND '), *values).order("name, created_at DESC")
        
      
        

          
          
          
        
      
        

          
          
              # cache the set of object keys in case we need them later
        
      
        

          
          
              cache_list(@activities, INDEX_KEY_LIST_VAR)
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.js
        
      
        

          
          
                format.html
        
      
        

          
          
                format.json { render :json => @activities }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # GET /activities/1
        
      
        

          
          
            # GET /activities/1.json
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def show
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb @activity
        
      
        

          
          
          
        
      
        

          
          
              # get the @prev_record_path and @next_record_path view vars
        
      
        

          
          
              get_next_and_prev_object_keys(@activity, INDEX_KEY_LIST_VAR)
        
      
        

          
          
              @prev_record_path = @prev_record_key.nil? ? "#" : activity_path(@prev_record_key)
        
      
        

          
          
              @next_record_path = @next_record_key.nil? ? "#" : activity_path(@next_record_key)
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # GET /activities/new
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def new
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb "New Activity"
        
      
        

          
          
          
        
      
        

          
          
              @activity = Activity.new
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # GET /activities/1/edit
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def edit
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb @activity, activity_path(@activity)
        
      
        

          
          
              add_breadcrumb "Update"
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # POST /activities
        
      
        

          
          
            # POST /activities.json
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def create
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb "New Activity"
        
      
        

          
          
          
        
      
        

          
          
              @activity = Activity.new(activity_params)
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @activity.save
        
      
        

          
          
                  notify_user :notice, 'Activity was successfully created.'
        
      
        

          
          
                  format.html { redirect_to @activity }
        
      
        

          
          
                  format.json { render :show, status: :created, location: @activity }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :new }
        
      
        

          
          
                  format.json { render json: @activity.errors, status: :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # PATCH/PUT /activities/1
        
      
        

          
          
            # PATCH/PUT /activities/1.json
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def update
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb @activity, activity_path(@activity)
        
      
        

          
          
              add_breadcrumb "Update"
        
      
        

          
          
          
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                if @activity.update(activity_params)
        
      
        

          
          
                  notify_user :notice, 'Activity was successfully updated.'
        
      
        

          
          
                  format.html { redirect_to @activity }
        
      
        

          
          
                  format.json { render :show, status: :ok, location: @activity }
        
      
        

          
          
                else
        
      
        

          
          
                  format.html { render :edit }
        
      
        

          
          
                  format.json { render json: @activity.errors, status: :unprocessable_entity }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
            # DELETE /activities/1
        
      
        

          
          
            # DELETE /activities/1.json
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            def destroy
        
      
        

          
          
              @activity.destroy
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                notify_user :notice, 'Activity was successfully removed.'
        
      
        

          
          
                format.html { redirect_to activities_url }
        
      
        

          
          
                format.json { head :no_content }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          1
          
            private
        
      
        

          
          
            #-----------------------------------------------------------------------------
        
      
        

          
          
          
        
      
        

          
          
            # Use callbacks to share common setup or constraints between actions.
        
      
        

          1
          
            def set_activity
        
      
        

          
          
              @activity = Activity.find_by(:object_key => params[:id])
        
      
        

          
          
              if @activity.nil?
        
      
        

          
          
                redirect_to '/404'
        
      
        

          
          
                return
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Never trust parameters from the scary internet, only allow the white list through.
        
      
        

          1
          
            def activity_params
        
      
        

          
          
              params.require(:activity).permit(Activity.allowable_params)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def reformat_date(date_str)
        
      
        

          
          
              form_date = Date.strptime(date_str, '%m/%d/%Y')
        
      
        

          
          
              return form_date.strftime('%Y-%m-%d')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def reformat_date_fields
        
      
        

          
          
              params[:activity][:start_date]  = reformat_date(params[:activity][:start_date]) unless params[:activity][:start_date].blank?
        
      
        

          
          
              params[:activity][:end_date]    = reformat_date(params[:activity][:end_date]) unless params[:activity][:end_date].blank?
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end